home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWPart / Sources / FWFrming.cpp < prev    next >
Encoding:
Text File  |  1995-11-08  |  33.6 KB  |  1,024 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWFrming.cpp
  4. //    Release Version:    $ 1.0d11 $
  5. //
  6. //    Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "FWFrameW.hpp"
  11.  
  12. #ifndef FWFRMING_H
  13. #include "FWFrming.h"
  14. #endif
  15.  
  16. #ifndef FWPARTNG_H
  17. #include "FWPartng.h"
  18. #endif
  19.  
  20. #ifndef FWPXYFRM_H
  21. #include "FWPxyFrm.h"
  22. #endif
  23.  
  24. #ifndef FWPROXY_H
  25. #include "FWProxy.h"
  26. #endif
  27.  
  28. #ifndef FWUTIL_H
  29. #include "FWUtil.h"
  30. #endif
  31.  
  32. #ifndef FWITERS_H
  33. #include "FWIters.h"
  34. #endif
  35.  
  36. #ifndef FWPRESEN_H
  37. #include "FWPresen.h"
  38. #endif
  39.  
  40. #ifndef FWSLCING_H
  41. #include "FWSlcing.h"
  42. #endif
  43.  
  44. #ifndef FWTRACKR_H
  45. #include "FWTrackr.h"
  46. #endif
  47.  
  48. #ifndef FWFRMINF_H
  49. #include "FWFrmInf.h"
  50. #endif
  51.  
  52. #ifndef FWPRTITE_H
  53. #include "FWPrtIte.h"
  54. #endif
  55.  
  56. // ----- OS Layer -----
  57.  
  58. #ifndef FWODGEOM_H
  59. #include "FWODGeom.h"
  60. #endif
  61.  
  62. #ifndef FWMNUBAR_H
  63. #include "FWMnuBar.h"
  64. #endif
  65.  
  66. #ifndef FWEVENT_H
  67. #include "FWEvent.h"
  68. #endif
  69.  
  70. #ifndef FWCURSOR_H
  71. #include "FWCursor.h"
  72. #endif
  73.  
  74. // ----- OpenDoc Includes -----
  75.  
  76. #ifndef SOM_ODDraft_xh
  77. #include <Draft.xh>
  78. #endif
  79.  
  80. #ifndef SOM_ODArbitrator_xh
  81. #include <Arbitrat.xh>
  82. #endif
  83.  
  84. #ifndef SOM_Module_OpenDoc_Commands_defined
  85. #include <CmdDefs.xh>
  86. #endif
  87.  
  88. #ifndef SOM_ODInfo_xh
  89. #include <Info.xh>
  90. #endif
  91.  
  92. #ifndef SOM_ODSession_xh
  93. #include <ODSessn.xh>
  94. #endif
  95.  
  96. #ifndef SOM_ODDispatcher_xh
  97. #include <Disptch.xh>
  98. #endif
  99.  
  100. //========================================================================================
  101. // RunTime Info
  102. //========================================================================================
  103.  
  104. #if FW_LIB_EXPORT_PRAGMAS
  105. #pragma lib_export on
  106. #endif
  107.  
  108. #ifdef FW_BUILD_MAC
  109. #pragma segment fw_embedding
  110. #endif
  111.  
  112. FW_DEFINE_CLASS_M1(FW_CEmbeddingFrame, FW_CFrame)
  113.  
  114. //========================================================================================
  115. //    class FW_CEmbeddingFrame
  116. //========================================================================================
  117.  
  118. //----------------------------------------------------------------------------------------
  119. //    FW_CEmbeddingFrame::FW_CEmbeddingFrame
  120. //----------------------------------------------------------------------------------------
  121.  
  122. FW_CEmbeddingFrame::FW_CEmbeddingFrame(Environment* ev,
  123.                                         ODFrame* odFrame, 
  124.                                         FW_CPresentation* presentation,
  125.                                         FW_CEmbeddingPart* part) :
  126.     FW_CFrame(ev, odFrame, presentation, part),
  127.     fProxyFrames(NULL)
  128. {
  129.     fProxyFrames = new FW_CPrivOrderedCollection;
  130. }
  131.  
  132. //----------------------------------------------------------------------------------------
  133. //    FW_CEmbeddingFrame::~FW_CEmbeddingFrame
  134. //----------------------------------------------------------------------------------------
  135.  
  136. FW_CEmbeddingFrame::~FW_CEmbeddingFrame()
  137. {
  138.     if (fProxyFrames)
  139.     {    
  140.         Environment* ev = somGetGlobalEnvironment();
  141.         FW_CProxyFrame* proxyFrame = (FW_CProxyFrame*)fProxyFrames->First();
  142.         while (proxyFrame != NULL)
  143.         {
  144.             PrivRemoveProxyFrame(ev, proxyFrame);
  145.             proxyFrame = (FW_CProxyFrame*)fProxyFrames->First();
  146.         }
  147.                 
  148.         delete fProxyFrames;
  149.         fProxyFrames = NULL;
  150.     }
  151. }
  152.  
  153. //----------------------------------------------------------------------------------------
  154. //    FW_CEmbeddingFrame::EmbeddedFrameRequested    
  155. //----------------------------------------------------------------------------------------
  156.  
  157. ODFrame* FW_CEmbeddingFrame::EmbeddedFrameRequested(Environment *ev,
  158.                                                     ODFrame* odBaseFrame,
  159.                                                     ODShape* frameShape,
  160.                                                     ODPart* embeddedPart,
  161.                                                     ODTypeToken viewType,
  162.                                                     ODTypeToken presentation,
  163.                                                     ODBoolean isOverlaid)
  164. {
  165.     return NULL;
  166. }
  167.  
  168. //----------------------------------------------------------------------------------------
  169. //    FW_CEmbeddingFrame::GetProxy    
  170. //----------------------------------------------------------------------------------------
  171.  
  172. FW_MProxy* FW_CEmbeddingFrame::GetProxy(Environment *ev,
  173.                                     ODFrame* embeddedFrame) const
  174. {
  175.     FW_ASSERT(embeddedFrame != NULL);
  176.     
  177.     ODID embeddedFrameID = embeddedFrame->GetID(ev);
  178.     
  179.     FW_CFrameProxyFrameIterator iter(this);
  180.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  181.     {
  182.         if (proxyFrame->GetFrameID(ev) == embeddedFrameID)
  183.             return proxyFrame->GetProxy(ev);
  184.     }
  185.     
  186.     return NULL;
  187. }
  188.  
  189. //----------------------------------------------------------------------------------------
  190. //    FW_CEmbeddingFrame::PrivCreateEmbeddedFrame
  191. //----------------------------------------------------------------------------------------
  192. //    the returned proxyframe should be release by the caller
  193.  
  194. FW_DECLARE_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFrame);
  195.  
  196. FW_CProxyFrame* FW_CEmbeddingFrame::PrivCreateEmbeddedFrame(Environment* ev,
  197.                                                             ODType frameType,
  198.                                                             ODPart *embeddedODPart,
  199.                                                             FW_MProxy* proxy,        // can be null
  200.                                                             ODShape* frameShape,    
  201.                                                             ODCanvas* biasCanvas,    // can be null
  202.                                                             ODTypeToken viewType,
  203.                                                             ODTypeToken presentationType,
  204.                                                             ODID frameGroupID,
  205.                                                             FW_Boolean isOverlaid,
  206.                                                             FW_Boolean subFrame)
  207. {
  208.     FW_CEmbeddingPart* embeddingPart = (FW_CEmbeddingPart*)GetPart(ev);
  209.     
  210.     ODStorageUnit* su = embeddingPart->GetStorageUnit(ev);
  211.  
  212.     if (presentationType == 0)
  213.         presentationType = GetPart(ev)->GetSession(ev)->Tokenize(ev, kODPresDefault);
  214.         
  215.     // ----- create the new frame
  216.     FW_CAcquiredODFrame embeddedODFrame = su->GetDraft(ev)->CreateFrame(ev, 
  217.                                                             frameType,
  218.                                                             GetODFrame(ev), 
  219.                                                             frameShape, 
  220.                                                             biasCanvas,
  221.                                                             embeddedODPart, 
  222.                                                             viewType, 
  223.                                                             presentationType, 
  224.                                                             subFrame, 
  225.                                                             isOverlaid);
  226.                                                             
  227.     embeddedODFrame->SetFrameGroup(ev, frameGroupID);
  228.     
  229.     // Testing: can the caller deal with this method failing?
  230.     FW_CHECK_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFrame);
  231.     
  232.     // ----- Create the proxyFrame for this embedded frame -----
  233.     FW_CProxyFrame* proxyFrame = new FW_CProxyFrame(ev, GetPart(ev), proxy, this, embeddedODFrame);
  234.     
  235.     return proxyFrame;
  236. }
  237.  
  238. //----------------------------------------------------------------------------------------
  239. //    FW_CEmbeddingFrame::PrivCreateEmbeddedFacets
  240. //----------------------------------------------------------------------------------------
  241.  
  242. FW_DECLARE_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFacets);
  243.  
  244. void FW_CEmbeddingFrame::PrivCreateEmbeddedFacets(Environment* ev, FW_MProxy* proxy, FW_CProxyFrame* proxyFrame)                                        
  245. {    
  246.     FW_ASSERT(proxy);
  247.     FW_ASSERT(proxyFrame);
  248.  
  249.     FW_CFrameFacetIterator ite(ev, this);
  250.     // Exception Handling: as with all loops, if one pass fails we need to undo the 
  251.     // effects of the previous ones.
  252.     FW_TRY {
  253.         for (ODFacet* containingFacet = ite.First(ev); ite.IsNotComplete(ev); containingFacet = ite.Next(ev))
  254.         {
  255.             PrivCreateEmbeddedFacet(ev, proxy, proxyFrame, containingFacet);
  256.             
  257.             // Testing: what happens if one facet is created and then we fail? (as 
  258.             // if we tried and failed to create two facets?)
  259.             FW_CHECK_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFacets);
  260.         }
  261.     }
  262.     FW_CATCH_BEGIN
  263.     FW_CATCH_EVERYTHING () {
  264.         PrivRemoveEmbeddedFacets (ev, proxyFrame);
  265.         FW_THROW_SAME ();
  266.     }
  267.     FW_CATCH_END
  268. }
  269.  
  270. //----------------------------------------------------------------------------------------
  271. //    FW_CEmbeddingFrame::PrivCreateEmbeddedFacet
  272. //----------------------------------------------------------------------------------------
  273.  
  274. FW_DECLARE_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFacet);
  275.  
  276. void FW_CEmbeddingFrame::PrivCreateEmbeddedFacet(Environment* ev, FW_MProxy* proxy, FW_CProxyFrame* proxyFrame, ODFacet* embeddingFacet)                                        
  277. {
  278.     FW_ASSERT(proxy);
  279.     FW_ASSERT(proxyFrame);
  280.     FW_ASSERT(embeddingFacet);
  281.     
  282.     if (!proxyFrame->IsFrameInMemory(ev))
  283.         return;
  284.     
  285.     ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  286.     
  287.     FW_CAcquiredODShape proposedClipShape = FW_CopyAndRelease(ev, embeddedFrame->AcquireFrameShape(ev, NULL));
  288.  
  289. /*
  290. // [HLX] DR4 bug??? I have to be sure that the embedded part is loaded before created embedded
  291. //    facet otherwise the embedded part FacetAdded method is going to be called twice. Once by
  292. //    ODFrame::AcquirePart and once by ODFrame::FacetAdded
  293.     FW_CAcquiredODPart embeddedPart = embeddedFrame->AcquirePart(ev);
  294. // [HLX] DR4 bug???
  295. */
  296.  
  297.     this->CreateEmbeddedFacet(ev,
  298.                             embeddingFacet,
  299.                             proxy,
  300.                             embeddedFrame,
  301.                             proposedClipShape);
  302.     
  303.     // ----- I need to go through all the embedded facets because I don't know how many where added -----
  304.     // For example, if we embedded Puzzle part then it would create 9 embedded facets. That's
  305.     // why CreateEmbeddedFacet doesn't return a pointer to the "one" created facet.
  306.     FW_TRY {
  307.         FW_CFacetIterator ite(ev, embeddingFacet, kODChildrenOnly, kODFrontToBack);
  308.         for (ODFacet* embeddedFacet = ite.First(ev); ite.IsNotComplete(ev); embeddedFacet = ite.Next(ev))
  309.         {
  310.             if (embeddedFacet->GetFrame(ev) == embeddedFrame)
  311.             {
  312.                 embeddedFacet->SetSelected(ev, proxy->GetSelectState(ev));
  313.                 this->EmbeddedFacetAdded(ev, embeddedFacet);
  314.                 proxy->PrivEmbeddedFacetAdded(ev);
  315.             }
  316.             
  317.             // Testing: what happens if one facet is created and then we fail? (as 
  318.             // if we tried and failed to create two facets?)
  319.             FW_CHECK_THROW_POINT (FW_CEmbeddingFrame_PrivCreateEmbeddedFacet);
  320.         }
  321.     }
  322.     FW_CATCH_BEGIN 
  323.     FW_CATCH_EVERYTHING () {
  324.         // This actually removes embedded facets of the proxyFrame *in* this embeddingFacet
  325.         PrivRemoveEmbeddedFacet (ev, proxyFrame, embeddingFacet);
  326.         FW_THROW_SAME ();
  327.     }
  328.     FW_CATCH_END
  329. }
  330.  
  331. //----------------------------------------------------------------------------------------
  332. //    FW_CEmbeddingFrame::PrivRemoveEmbeddedFacets
  333. //----------------------------------------------------------------------------------------
  334.  
  335. void FW_CEmbeddingFrame::PrivRemoveEmbeddedFacets(Environment* ev, FW_CProxyFrame* proxyFrame)
  336. {
  337.     FW_CFrameFacetIterator ite(ev, this);
  338.     for (ODFacet* facet = ite.First(ev); ite.IsNotComplete(ev); facet = ite.Next(ev))
  339.         PrivRemoveEmbeddedFacet(ev, proxyFrame, facet);
  340. }
  341.  
  342. //----------------------------------------------------------------------------------------
  343. //    FW_CEmbeddingFrame::PrivRemoveEmbeddedFacet
  344. //----------------------------------------------------------------------------------------
  345.  
  346. void FW_CEmbeddingFrame::PrivRemoveEmbeddedFacet(Environment* ev, FW_CProxyFrame* proxyFrame, ODFacet* embeddingFacet)
  347. {
  348.     FW_ASSERT(proxyFrame != NULL);
  349.     FW_ASSERT(embeddingFacet != NULL);
  350.     
  351.     if (!proxyFrame->IsFrameInMemory(ev))    // if not in memory should not have any facets
  352.         return;
  353.     
  354.     ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  355.     
  356.     FW_CPrivOrderedCollection tempCollect;
  357.  
  358.     // Attention: Do not try to iterate through all the facets of the embedded frame because
  359.     //    if we are in a middle of a drag&drop, the embedded frame may already have been stripped
  360.     //    of all its facets (in the case where the frame is reused, SetContainingFrame is called
  361.     //    which remove all the facets of the frame). But the hierarchy of facets is still there
  362.     FW_CFacetIterator ite(ev, embeddingFacet, kODChildrenOnly, kODFrontToBack);
  363.     ODFacet* facet;
  364.     for (facet = ite.First(ev); ite.IsNotComplete(ev); facet = ite.Next(ev))
  365.     {
  366.         if (facet->GetFrame(ev) == embeddedFrame)
  367.             tempCollect.AddLast(facet);
  368.     }
  369.     
  370.     FW_MProxy* proxy = proxyFrame->GetProxy(ev);
  371.         
  372.     FW_COrderedCollectionIterator ite2(&tempCollect);
  373.     for (facet = (ODFacet*)ite2.First(); ite2.IsNotComplete(); facet = (ODFacet*)ite2.Next())
  374.     {
  375.         this->EmbeddedFacetRemoved(ev, facet);
  376.         proxy->PrivEmbeddedFacetRemoved(ev);
  377.         
  378.         embeddingFacet->RemoveFacet(ev, facet);
  379.         delete facet;
  380.     }
  381.     
  382.     // RemoveAll will be called by the destructor of tempCollect 
  383.     // tempCollect.RemoveAll();
  384. }
  385.  
  386. //----------------------------------------------------------------------------------------
  387. //     FW_CEmbeddingFrame::Activate
  388. //----------------------------------------------------------------------------------------
  389. // [HLX] Temporary hack. To be removed (See FW_CFrame::FocusChanged)
  390.  
  391. FW_Boolean FW_CEmbeddingFrame::Activate(Environment* ev)
  392. {
  393.     FW_Boolean result = FW_CFrame::Activate(ev);
  394.     
  395.     if (result)
  396.     {
  397.         FW_CFrameProxyFrameIterator iter(this);
  398.         for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  399.         {
  400.             if (proxyFrame->IsFrameInMemory(ev) && proxyFrame->GetProxy(ev)->GetSelectState(ev))
  401.             {
  402.                 FW_CODFrameFacetIterator ite(ev, proxyFrame->GetFrame(ev));
  403.                 for (ODFacet* facet = ite.First(ev); ite.IsNotComplete(ev); facet = ite.Next(ev))
  404.                 {
  405.                     facet->SetSelected(ev, TRUE);
  406.                 }
  407.             }
  408.         }
  409.     }
  410.     
  411.     return result;
  412. }
  413.  
  414. //----------------------------------------------------------------------------------------
  415. //     FW_CEmbeddingFrame::Deactivate
  416. //----------------------------------------------------------------------------------------
  417. // [HLX] Temporary hack. To be removed (See FW_CFrame::FocusChanged)
  418.  
  419. void FW_CEmbeddingFrame::Deactivate(Environment* ev)
  420. {
  421.     FW_CFrame::Deactivate(ev);
  422.     
  423.     FW_CFrameFacetIterator iter(ev, this);
  424.     for (ODFacet* facet = iter.First(ev); iter.IsNotComplete(ev); facet = iter.Next(ev))
  425.     {
  426.         FW_CFacetIterator ite(ev, facet, kODChildrenOnly, kODFrontToBack);
  427.         for (ODFacet* embeddedFacet = ite.First(ev); ite.IsNotComplete(ev); embeddedFacet = ite.Next(ev))
  428.         {
  429.             embeddedFacet->SetSelected(ev, FALSE);
  430.         }
  431.     }
  432. }
  433.  
  434. //----------------------------------------------------------------------------------------
  435. //    FW_CEmbeddingFrame::GetPart
  436. //----------------------------------------------------------------------------------------
  437.  
  438. FW_CEmbeddingPart* FW_CEmbeddingFrame::GetPart(Environment *ev) const
  439. {
  440.     return (FW_CEmbeddingPart*)FW_CFrame::GetPart(ev);
  441. }
  442.  
  443. //----------------------------------------------------------------------------------------
  444. //    FW_CEmbeddingFrame::FrameAdded
  445. //----------------------------------------------------------------------------------------
  446.  
  447. void FW_CEmbeddingFrame::FrameAdded(Environment* ev, FW_Boolean fromStorage)
  448. {
  449.     // ----- Call inherited -----
  450.     FW_CFrame::FrameAdded(ev, fromStorage);
  451.  
  452.     // ----- Attach to myself all the proxyFrame having myself as container -----
  453.     if (fromStorage)
  454.     {
  455.         FW_CPartProxyFrameIterator ite(GetPart(ev));
  456.         for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  457.         {
  458.             if (proxyFrame->GetContainingFrameID(ev) == this->GetID(ev))
  459.             {
  460.                 this->PrivAddProxyFrame(ev, proxyFrame);
  461.                 
  462.                 // [HLX] for now lets make them all visible
  463.                 proxyFrame->GetFrame(ev);
  464.             }
  465.         }
  466.     }
  467.     else
  468.     {
  469.         PrivAttachOrphans(ev);
  470.     }
  471. }
  472.  
  473. //----------------------------------------------------------------------------------------
  474. //    FW_CEmbeddingFrame::PageEmbeddedFrames
  475. //----------------------------------------------------------------------------------------
  476.  
  477. void FW_CEmbeddingFrame::PageEmbeddedFrames(Environment* ev)
  478. {
  479.     if (!GetPart(ev)->IsSupportingFramePaging(ev))
  480.         return;
  481.  
  482. /*    
  483.     FW_CFrameProxyFrameIterator ite1(this);
  484.     for (FW_CProxyFrame* proxyFrame = ite1.First(); ite1.IsNotComplete(); proxyFrame = ite1.Next())
  485.     {    
  486.         FW_CRect bounds;
  487.         proxyFrame->GetProxy(ev)->GetProxyBounds(ev, this, bounds);
  488.             
  489.         FW_Boolean purgeable = TRUE;
  490.         FW_CFrameFacetIterator ite(ev, this);
  491.         for (ODFacet* facet = ite.First(ev); ite.IsNotComplete(ev); facet = ite.Next(ev))
  492.         {
  493.             if (proxyFrame->IsVisible(ev, facet, bounds))
  494.             {
  495.                 purgeable = FALSE;
  496.                 break;
  497.             }
  498.         }
  499.         
  500.         proxyFrame->SetPurgeable(ev, purgeable);
  501.     }
  502. */
  503. }
  504.  
  505. //----------------------------------------------------------------------------------------
  506. //    FW_CEmbeddingFrame::PrivAttachOrphans
  507. //----------------------------------------------------------------------------------------
  508.  
  509. void FW_CEmbeddingFrame::PrivAttachOrphans(Environment* ev)
  510. {
  511.     FW_CPartProxyFrameIterator ite(GetPart(ev));
  512.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  513.     {
  514.         if (proxyFrame->IsOrphan(ev))
  515.         {
  516.             this->PrivAddProxyFrame(ev, proxyFrame);
  517.             proxyFrame->SetContainingFrame(ev, this);    // Don't call RevealProxyFrame because SetContainingFrame does it
  518.         }
  519.     }
  520. }
  521.  
  522. //----------------------------------------------------------------------------------------
  523. //    FW_CEmbeddingFrame::PrivAttachSourceFrame
  524. //----------------------------------------------------------------------------------------
  525. //    FW_CEmbeddingFrame::AttachSourceFrame should not be called if sourceFrame == NULL
  526.  
  527. void FW_CEmbeddingFrame::PrivAttachSourceFrame(Environment* ev, FW_CFrame* sourceFrame)
  528. {
  529.     FW_ASSERT(sourceFrame != NULL);
  530.     
  531.     FW_CFrame::PrivAttachSourceFrame(ev, sourceFrame);
  532.     
  533.     // ----- If I am an embedding frame, sourceFrame must be too
  534.     FW_CEmbeddingFrame* embeddingSourceFrame = FW_DYNAMIC_CAST(FW_CEmbeddingFrame, sourceFrame);
  535.     FW_ASSERT(embeddingSourceFrame);
  536.  
  537.     // ----- Duplicate all the embedded frames of sourceFrame -----
  538.     // ----- PrivCreateEmbeddedFrame doesn't create facets, wait for FacetAdded to duplicate my facets -----
  539.     FW_CFrameProxyFrameIterator iter(embeddingSourceFrame);
  540.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  541.     {    
  542.         FW_Boolean wasInMemory = proxyFrame->IsFrameInMemory(ev);
  543.         
  544.         // ----- get the embedded frame -----
  545.         ODFrame* odEmbeddedFrame = proxyFrame->GetFrame(ev);        
  546.         
  547.         // ----- get the embedded part -----
  548.         FW_CAcquiredODPart aqODEmbeddedPart = odEmbeddedFrame->AcquirePart(ev);
  549.     
  550.         // ----- Create the embedded Frame (proxyFrame) -----
  551.         FW_CAcquiredODShape aqFrameShapeCopy(FW_CopyAndRelease(ev, odEmbeddedFrame->AcquireFrameShape(ev, NULL)));
  552.         
  553.         FW_CAcquiredProxyFrame aqNewProxyFrame = PrivCreateEmbeddedFrame(ev,
  554.                                                                         kODFrameObject,    // Always create embedded frames persistent
  555. //                                                                        IsPersistent(ev) ? kODFrameObject : kODNonPersistentFrameObject,
  556.                                                                         aqODEmbeddedPart,
  557.                                                                         proxyFrame->GetProxy(ev),                // same proxy as source
  558.                                                                         aqFrameShapeCopy,
  559.                                                                         NULL,                                    // bias Canvas
  560.                                                                         odEmbeddedFrame->GetViewType(ev),
  561.                                                                         odEmbeddedFrame->GetPresentation(ev),
  562.                                                                         odEmbeddedFrame->GetFrameGroup(ev),
  563.                                                                         odEmbeddedFrame->IsOverlaid(ev),
  564.                                                                         odEmbeddedFrame->IsSubframe(ev));
  565.                 
  566.         // ----- Add the embedded frame to the embedded part -----
  567.         aqODEmbeddedPart->AttachSourceFrame(ev, aqNewProxyFrame->GetFrame(ev), odEmbeddedFrame);
  568.                 
  569.         // ----- If was not in memory close it down -----
  570.         if (!wasInMemory)
  571.             odEmbeddedFrame->Close(ev);
  572.     }
  573. }
  574.  
  575. //----------------------------------------------------------------------------------------
  576. //    FW_CEmbeddingFrame::PrivAcquireProxyFrame
  577. //----------------------------------------------------------------------------------------
  578.  
  579. FW_CProxyFrame* FW_CEmbeddingFrame::PrivAcquireProxyFrame(Environment* ev, ODStorageUnitID frameID) const
  580. {
  581.     return FW_CProxyFrame::PrivAcquireProxyFrame(ev, fProxyFrames, frameID);
  582. }
  583.  
  584. //----------------------------------------------------------------------------------------
  585. //    FW_CEmbeddingFrame::PrivRemoveEmbeddedFrame
  586. //----------------------------------------------------------------------------------------
  587.  
  588. void FW_CEmbeddingFrame::PrivRemoveEmbeddedFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  589. {
  590.     //     If called means that the embedded frame is in memory
  591.     //    Be sure it is in memory
  592.     ODFrame* odEmbeddedFrame = proxyFrame->GetFrame(ev);
  593.  
  594.     // ----- Detach the proxyframe -----
  595.     proxyFrame->PrivDetach(ev);
  596.  
  597.     // ----- remove it from the proxy
  598.     long refCount = proxyFrame->GetProxy(ev)->PrivRemoveProxyFrame(ev, proxyFrame);
  599.     
  600.     FW_ASSERT(refCount == 0);
  601. }
  602.  
  603. //----------------------------------------------------------------------------------------
  604. //    FW_CEmbeddingFrame::EmbeddedFrameSpec    
  605. //----------------------------------------------------------------------------------------
  606.  
  607. void FW_CEmbeddingFrame::EmbeddedFrameSpec(Environment *ev, ODFrame* odEmbeddedFrame, ODObjectSpec* spec)
  608. {
  609. FW_UNUSED(odEmbeddedFrame);
  610. FW_UNUSED(spec);
  611. }
  612.  
  613. //----------------------------------------------------------------------------------------
  614. //    FW_CEmbeddingFrame::FrameRemoved
  615. //----------------------------------------------------------------------------------------
  616. //    I should not have to worry about my embedded facets because before the frame is removed
  617. //    its facets should have been removed, removing the embedded facets
  618.  
  619. void FW_CEmbeddingFrame::FrameRemoved(Environment* ev, FW_Boolean toStorage)
  620. {
  621.     // ----- Collect the proxyFrames in a temporary collections -----
  622.     FW_CPrivOrderedCollection tempCollect;
  623.     FW_CProxyFrame* proxyFrame;
  624.  
  625.     FW_CFrameProxyFrameIterator ite1(this);
  626.     for (proxyFrame = ite1.First(); ite1.IsNotComplete(); proxyFrame = ite1.Next())
  627.     {
  628.         tempCollect.AddLast(proxyFrame);
  629.     }
  630.  
  631.     // ----- Now we can call close or remove
  632.     FW_COrderedCollectionIterator ite2(&tempCollect);
  633.     for (proxyFrame = (FW_CProxyFrame*)ite2.First(); ite2.IsNotComplete(); proxyFrame = (FW_CProxyFrame*)ite2.Next())
  634.     {
  635.         if (toStorage)
  636.             proxyFrame->Close(ev);
  637.         else
  638.             this->PrivRemoveEmbeddedFrame(ev, proxyFrame);
  639.     }
  640.     
  641.     // Don't have to call tempCollect.RemoveAll() because the __dt does it
  642.     
  643.     // ----- Call inherited -----
  644.     FW_CFrame::FrameRemoved(ev, toStorage);
  645. }
  646.  
  647. //----------------------------------------------------------------------------------------
  648. //    FW_CEmbeddingFrame::FacetAdded
  649. //----------------------------------------------------------------------------------------
  650. //    When overridden call inherited::FacetAdded FIRST
  651.  
  652. void FW_CEmbeddingFrame::FacetAdded(Environment* ev, ODFacet* facet)
  653. {    
  654.     // ----- Call inherited first
  655.     FW_CFrame::FacetAdded(ev, facet);
  656.     
  657.     // ----- Add facets to each one of my embedded frame (that are in memory) -----
  658.     FW_CFrameProxyFrameIterator ite(this);
  659.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  660.     {
  661.         PrivCreateEmbeddedFacet(ev, proxyFrame->GetProxy(ev), proxyFrame, facet);
  662.     }
  663. }
  664.  
  665. //----------------------------------------------------------------------------------------
  666. //    FW_CEmbeddingFrame::FacetRemoved
  667. //----------------------------------------------------------------------------------------
  668. //    When overridden call inherited::FacetRemoved LAST
  669.  
  670. void FW_CEmbeddingFrame::FacetRemoved(Environment* ev, ODFacet* facet)
  671. {
  672.     // ----- Remove Embedded Facets
  673.     FW_CFrameProxyFrameIterator ite(this);
  674.     for (FW_CProxyFrame* proxyFrame = ite.First(); ite.IsNotComplete(); proxyFrame = ite.Next())
  675.         PrivRemoveEmbeddedFacet(ev, proxyFrame, facet);
  676.     
  677.     // ----- Call inherited
  678.     FW_CFrame::FacetRemoved(ev, facet);
  679. }
  680.  
  681. //----------------------------------------------------------------------------------------
  682. //    FW_CEmbeddingFrame::EmbeddedFacetAdded
  683. //----------------------------------------------------------------------------------------
  684.  
  685. void FW_CEmbeddingFrame::EmbeddedFacetAdded(Environment* ev, ODFacet* odFacet)
  686. {
  687. FW_UNUSED(odFacet);
  688. }
  689.  
  690. //----------------------------------------------------------------------------------------
  691. //    FW_CEmbeddingFrame::EmbeddedFacetRemoved
  692. //----------------------------------------------------------------------------------------
  693.  
  694. void FW_CEmbeddingFrame::EmbeddedFacetRemoved(Environment* ev, ODFacet* odFacet)
  695. {
  696. FW_UNUSED(odFacet);
  697. }
  698.  
  699. //----------------------------------------------------------------------------------------
  700. //    FW_CEmbeddingFrame::HasASelectedEmbeddedFacet
  701. //----------------------------------------------------------------------------------------
  702.  
  703. FW_Boolean FW_CEmbeddingFrame::HasASelectedEmbeddedFacet(Environment* ev) const
  704. {
  705.     FW_CFrameProxyFrameIterator iter(this);
  706.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  707.     {
  708.         if (proxyFrame->HasASelectedFacet(ev))
  709.             return TRUE;
  710.     }
  711.     
  712.     return FALSE;
  713. }
  714.  
  715. //----------------------------------------------------------------------------------------
  716. //    FW_CEmbeddingFrame::HandleAdjustMenus
  717. //----------------------------------------------------------------------------------------
  718.  
  719. FW_Boolean FW_CEmbeddingFrame::HandleAdjustMenus(Environment* ev, FW_CMenuBar* menuBar, 
  720.                                             FW_Boolean hasMenuFocus, FW_Boolean isRoot)
  721. {
  722.     if (hasMenuFocus)
  723.     {
  724.         menuBar->EnableCommand(ev, kODCommandGetPartInfo, HasASelectedEmbeddedFacet(ev));
  725.         menuBar->EnableCommand(ev, kODCommandOpen, HasASelectedEmbeddedFacet(ev));
  726.  
  727.         menuBar->EnableCommand(ev, kODCommandInsert, !GetPart(ev)->IsReadOnly(ev));
  728.  
  729. #ifdef FW_BUILD_WIN
  730.         GetPart(ev)->WinEnableEmbedMenu(ev, menuBar);
  731. #endif
  732.     }
  733.     
  734.     return FW_CFrame::HandleAdjustMenus(ev, menuBar, hasMenuFocus, isRoot);
  735. }
  736.  
  737. //----------------------------------------------------------------------------------------
  738. //    FW_CEmbeddingFrame::HandleMenu
  739. //----------------------------------------------------------------------------------------
  740.  
  741. FW_Boolean FW_CEmbeddingFrame::HandleMenu(Environment* ev, const FW_CMenuEvent& theMenuEvent)
  742. {
  743.     FW_Boolean result = TRUE;
  744.     ODCommandID commandID = theMenuEvent.GetCommandID(ev);
  745.     
  746. #ifdef FW_BUILD_WIN
  747.     ODPart *embeddedPart = GetPart(ev)->WinCreateEmbeddedPartFromCommand(ev, commandID);
  748.     if (embeddedPart != NULL)
  749.     {
  750.         this->EmbedSingleFrame(ev, embeddedPart, NULL, NULL);
  751.         return TRUE;
  752.     }
  753. #endif
  754.  
  755.     FW_CSelection* selection = this->GetPresentation(ev)->GetSelection(ev);
  756.     switch (commandID)
  757.     {
  758.         case kODCommandInsert:
  759.             if (selection)
  760.             {
  761.                 FW_ASSERT(!GetPart(ev)->IsReadOnly(ev));
  762.                 FW_ASSERT(FW_DYNAMIC_CAST(FW_CEmbeddingSelection, selection));
  763.                 result = ((FW_CEmbeddingSelection*)selection)->InsertNewPart(ev, this);
  764.             }
  765.             else
  766.                 FW_Beep();
  767.             break;
  768.             
  769.         case kODCommandGetPartInfo:
  770.             ShowPartInfo(ev);
  771.             break;
  772.             
  773.         case kODCommandOpen:
  774.             OpenSelection(ev);
  775.             break;
  776.  
  777.         default:
  778.             result = FW_CFrame::HandleMenu(ev, theMenuEvent);
  779.     };
  780.     
  781.     return result;
  782. }
  783.  
  784. //----------------------------------------------------------------------------------------
  785. //    FW_CEmbeddingFrame::OpenSelection
  786. //----------------------------------------------------------------------------------------
  787.  
  788. void FW_CEmbeddingFrame::OpenSelection(Environment* ev)
  789. {
  790.     //     I need to collect first the proxyframe that I want to open because opening the first 
  791.     //    window will unselect the other one
  792.     
  793.     FW_CProxyFrame* proxyFrame;
  794.     FW_CPrivOrderedCollection temp;
  795.  
  796.     FW_CFrameProxyFrameIterator iter(this);
  797.     for (proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  798.     {
  799.         if (proxyFrame->HasASelectedFacet(ev))
  800.             temp.AddLast(proxyFrame);
  801.     }
  802.     
  803.     FW_COrderedCollectionIterator iter2(&temp);
  804.     for (proxyFrame = (FW_CProxyFrame*)iter2.First(); iter2.IsNotComplete(); proxyFrame =  (FW_CProxyFrame*)iter2.Next())
  805.     {
  806.         ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  807.         FW_CAcquiredODPart aqODPart = embeddedFrame->AcquirePart(ev);
  808.         aqODPart->Open(ev, embeddedFrame);
  809.     }
  810.     
  811.     // the destructor of temp will call RemoveAll
  812. }
  813.  
  814. //----------------------------------------------------------------------------------------
  815. //    FW_CEmbeddingFrame::ShowPartInfo
  816. //----------------------------------------------------------------------------------------
  817.  
  818. void FW_CEmbeddingFrame::ShowPartInfo(Environment* ev)
  819. {
  820.     FW_CFrameProxyFrameIterator iter(this);
  821.     for (FW_CProxyFrame* proxyFrame = iter.First(); iter.IsNotComplete(); proxyFrame = iter.Next())
  822.     {
  823.         if (proxyFrame->HasASelectedFacet(ev))
  824.         {
  825.             FW_MProxy *proxy = proxyFrame->GetProxy(ev);
  826.             FW_ASSERT(proxy);
  827.         
  828.             // ----- Try first the active facet -----
  829.             ODFacet* facet = this->GetActiveFacet(ev);
  830.             
  831.             // ----- If not Active facet try the first facet -----
  832.             if (facet == NULL)
  833.             {
  834.                 FW_CFrameFacetIterator iteFrame(ev, this);
  835.                 facet = iteFrame.First(ev);
  836.             }
  837.             FW_ASSERT(facet != NULL);
  838.             
  839.             // [HLX] We are passing the first facet but we need to be a little bit more smart 
  840.             // about that. We should pass the selected one or if there is no selection do it on ourself
  841.             FW_CEmbeddedODFacetsIterator ite(ev, proxy, facet, kODFrontToBack);
  842.             ODFacet* firstEmbeddedFacet = ite.First(ev);
  843.             FW_ASSERT(firstEmbeddedFacet != NULL);
  844.             
  845.             ODFrame* embeddedFrame = proxyFrame->GetFrame(ev);
  846.             ODTypeToken oldViewType = embeddedFrame->GetViewType(ev);
  847.  
  848.             ODInfo* info = GetPart(ev)->GetSession(ev)->GetInfo(ev);
  849.             info->ShowPartFrameInfo(ev, firstEmbeddedFacet, !GetPart(ev)->IsReadOnly(ev));
  850.  
  851.             ODTypeToken newViewType = embeddedFrame->GetViewType(ev);
  852.             
  853.             // ----- Propagate the view type to other sibling frames -----
  854.             if (oldViewType != newViewType && GetPresentation(ev)->UseSameViewTypeForEmbeddedFrames(ev))
  855.             {
  856.                 FW_CProxyEmbeddedFrameIterator iter2(ev, proxy);
  857.                 for (ODFrame* sibling = iter2.First(ev); iter2.IsNotComplete(ev); sibling = iter2.Next(ev))
  858.                 {
  859.                     if (sibling->GetViewType(ev) != newViewType)
  860.                         sibling->ChangeViewType(ev, newViewType);
  861.                 }
  862.             }
  863.         }
  864.     }
  865. }
  866.  
  867. //----------------------------------------------------------------------------------------
  868. //    FW_CEmbeddingFrame::RevealFrame    
  869. //----------------------------------------------------------------------------------------
  870.  
  871. FW_Boolean FW_CEmbeddingFrame::RevealFrame(Environment *ev, 
  872.                                         ODFrame* embeddedFrame, 
  873.                                         ODShape* revealShape)
  874. {
  875.     FW_UNUSED(embeddedFrame);
  876.     FW_UNUSED(revealShape);
  877.  
  878.     return FALSE;
  879. }
  880.  
  881. //----------------------------------------------------------------------------------------
  882. //    FW_CEmbeddingFrame::CountProxyFrames
  883. //----------------------------------------------------------------------------------------
  884.  
  885. unsigned long FW_CEmbeddingFrame::CountProxyFrames(Environment* ev) const
  886. {
  887.     return fProxyFrames->Count();
  888. }
  889.  
  890. //----------------------------------------------------------------------------------------
  891. //    FW_CEmbeddingFrame::PrivAddProxyFrame
  892. //----------------------------------------------------------------------------------------
  893.  
  894. void FW_CEmbeddingFrame::PrivAddProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  895. {
  896. #ifdef FW_DEBUG
  897.     FW_CFrameProxyFrameIterator ite(this);
  898.     for (FW_CProxyFrame* pf = ite.First(); ite.IsNotComplete(); pf = ite.Next())
  899.     {
  900.         if (pf == proxyFrame)
  901.             FW_DEBUG_MESSAGE("FW_CEmbeddingFrame::PrivAddProxyFrame ProxyFrame already attached");
  902.     }
  903. #endif
  904.  
  905.     fProxyFrames->AddLast(proxyFrame);
  906.     proxyFrame->Acquire();
  907. }
  908.  
  909. //----------------------------------------------------------------------------------------
  910. //    FW_CEmbeddingFrame::ViewTypeChanged
  911. //----------------------------------------------------------------------------------------
  912.  
  913. void FW_CEmbeddingFrame::ViewTypeChanged(Environment* ev, ODTypeToken newViewType, ODTypeToken oldViewType)
  914. {
  915.     FW_CFrame::ViewTypeChanged(ev, newViewType, oldViewType);
  916.     
  917.     FW_CFrameProxyFrameIterator ite(this);
  918.     for (FW_CProxyFrame* proxyframe = ite.First(); ite.IsNotComplete(); proxyframe = ite.Next())
  919.     {
  920.         if (oldViewType == FW_CPart::gViewAsFrameToken)
  921.             PrivRemoveEmbeddedFacets(ev, proxyframe);
  922.         else
  923.             PrivCreateEmbeddedFacets(ev, proxyframe->GetProxy(ev), proxyframe);
  924.     }
  925. }
  926.  
  927. //----------------------------------------------------------------------------------------
  928. //    FW_CEmbeddingFrame::PrivRemoveProxyFrame
  929. //----------------------------------------------------------------------------------------
  930.  
  931. long FW_CEmbeddingFrame::PrivRemoveProxyFrame(Environment* ev, FW_CProxyFrame* proxyFrame)
  932. {
  933.     fProxyFrames->Remove(proxyFrame);
  934.     return proxyFrame->Release();
  935. }
  936.  
  937. //----------------------------------------------------------------------------------------
  938. //    FW_CEmbeddingFrame::AdjustCursor
  939. //----------------------------------------------------------------------------------------
  940.  
  941. FW_Boolean FW_CEmbeddingFrame::AdjustCursor(Environment *ev, ODFacet* odFacet, const FW_CPoint& theMousePoint)
  942. {
  943.     // ----- Test if mouse on the active border of an embedded facet -----
  944.     FW_Boolean cursorInActiveBorder = FALSE;
  945.     
  946.     ODArbitrator* arbitrator =  GetPart(ev)->GetSession(ev)->GetArbitrator(ev);
  947.     FW_CAcquiredODFrame aqActiveFrame = arbitrator->AcquireFocusOwner(ev, FW_CPart::gMenuFocusToken);
  948.     if (aqActiveFrame != NULL)
  949.     {
  950.         FW_CODFrameFacetIterator iter(ev, aqActiveFrame);
  951.         
  952.         FW_CAcquiredODTransform aqWindowFrameXForm = odFacet->AcquireWindowFrameTransform(ev, NULL);
  953.         FW_CPoint windowMouse = theMousePoint.TransformCopy(ev, aqWindowFrameXForm);
  954.         
  955.         for (ODFacet* facet = iter.First(ev); iter.IsNotComplete(ev); facet = iter.Next(ev))
  956.         {
  957.             FW_CAcquiredODTransform  aqxForm = facet->AcquireWindowFrameTransform(ev, NULL);
  958.             ODPoint odFramePoint = windowMouse.InverseTransformCopy(ev, aqxForm);
  959.             
  960.             if (facet->ActiveBorderContainsPoint(ev, &odFramePoint, NULL))
  961.             {
  962.                 cursorInActiveBorder = TRUE;
  963.                 break;
  964.             } 
  965.         }
  966.     }
  967.     
  968.     if (cursorInActiveBorder)
  969.         FW_gOpenHandCursor.Select();
  970.     
  971.     return cursorInActiveBorder;
  972. }
  973.  
  974. //----------------------------------------------------------------------------------------
  975. //    FW_CEmbeddingFrame::GetEmbeddedFacet
  976. //----------------------------------------------------------------------------------------
  977. //    Return the <first> facet belonging to proxy embedded in 'facet' 
  978.  
  979. ODFacet* FW_CEmbeddingFrame::GetEmbeddedFacet(Environment* ev, ODFacet* facet, FW_MProxy* proxy)
  980. {
  981.     FW_CFacetIterator i(ev, facet, kODChildrenOnly, kODFrontToBack);
  982.  
  983.     for (ODFacet* embeddedFacet = i.First(ev); i.IsNotComplete(ev); embeddedFacet = i.Next(ev))
  984.     {
  985.         FW_CAcquiredODPart aqODPart = embeddedFacet->GetFrame(ev)->AcquirePart(ev);
  986.         if (aqODPart == proxy->GetEmbeddedPart(ev))
  987.             return embeddedFacet;
  988.     }
  989.         
  990.     return NULL;
  991. }
  992.  
  993. //----------------------------------------------------------------------------------------
  994. //    FW_CEmbeddingFrame::CanAcceptDrop
  995. //----------------------------------------------------------------------------------------
  996. //     This is much simpler if we are an embedding part. We can accept just about anything
  997. //    Don't forget, CanAcceptDrop is not called if read only.
  998.  
  999. ODDragResult FW_CEmbeddingFrame::CanAcceptDrop(Environment *ev, ODDragItemIterator* dragInfo)
  1000. {
  1001. FW_UNUSED(ev);
  1002. FW_UNUSED(dragInfo);
  1003.  
  1004.     return TRUE;
  1005. }
  1006.  
  1007. //----------------------------------------------------------------------------------------
  1008. //    FW_CEmbeddingFrame::ODtoFWFrame
  1009. //----------------------------------------------------------------------------------------
  1010.  
  1011. FW_CEmbeddingFrame* FW_CEmbeddingFrame::ODtoFWEmbeddingFrame(Environment* ev, ODFrame* odFrame)
  1012. {
  1013.     FW_CEmbeddingFrame* frame = NULL;
  1014.     
  1015.     if (odFrame)
  1016.     {
  1017.         FW_CFramePartInfo* framePartInfo = (FW_CFramePartInfo*)odFrame->GetPartInfo(ev);
  1018.         frame = framePartInfo ? FW_DYNAMIC_CAST(FW_CEmbeddingFrame, framePartInfo->GetFrame()) : NULL;
  1019.     }
  1020.     
  1021.     return frame;
  1022. }
  1023.  
  1024.